from __future__ import print_function
import numpy as np
import pandas as pd
from ipywidgets import interact, interactive, fixed, interact_manual
import ipywidgets as widgets
# seed the random number generator
np.random.seed(1)
# Example: sampling
#
# do not forget that Python arrays are zero-indexed,
# and the 2nd argument to NumPy arange must be incremented by 1
# if you want to include that value
n = 6
k = 200000
T=np.random.choice(np.arange(1, n+1), k, replace=True)
unique, counts = np.unique(T, return_counts=True)
dic=dict(zip(unique, counts))
df=pd.DataFrame(list(dic.items()),columns=['i','Occurence'])
df.set_index(['i'], inplace=True)
df['Freq']=df['Occurence']/k
df['P({i})']='{}'.format(1/6)
df
Occurence | Freq | P({i}) | |
---|---|---|---|
i | |||
1 | 33346 | 0.166730 | 0.16666666666666666 |
2 | 33221 | 0.166105 | 0.16666666666666666 |
3 | 33447 | 0.167235 | 0.16666666666666666 |
4 | 33224 | 0.166120 | 0.16666666666666666 |
5 | 33379 | 0.166895 | 0.16666666666666666 |
6 | 33383 | 0.166915 | 0.16666666666666666 |
def dice_sim(k=100):
n = 6
T=np.random.choice(np.arange(1, n+1), k, replace=True)
unique, counts = np.unique(T, return_counts=True)
dic=dict(zip(unique, counts))
df=pd.DataFrame(list(dic.items()),columns=['i','Occurence'])
df.set_index(['i'], inplace=True)
df['Freq']=df['Occurence']/k
df['P({i})']='{0:.3f}'.format(1/6)
return df
dice_sim(100)
Occurence | Freq | P({i}) | |
---|---|---|---|
i | |||
1 | 19 | 0.19 | 0.167 |
2 | 16 | 0.16 | 0.167 |
3 | 17 | 0.17 | 0.167 |
4 | 15 | 0.15 | 0.167 |
5 | 15 | 0.15 | 0.167 |
6 | 18 | 0.18 | 0.167 |
interact(dice_sim,k=widgets.IntSlider(min=1000, max=50000, step=500, value=10));
interactive(children=(IntSlider(value=1000, description='k', max=50000, min=1000, step=500), Output()), _dom_c…
p=[0.1, 0.1, 0.1, 0.1,0.1,0.5]
sum(p)
1.0
def dice_sim(k=100,q=[[0.1, 0.1, 0.1, 0.1,0.1,0.5],[0.2, 0.1, 0.2, 0.1,0.1,0.3]]):
n = 6
qq=q
T=np.random.choice(np.arange(1, n+1), k, replace=True,p=qq)
unique, counts = np.unique(T, return_counts=True)
dic=dict(zip(unique, counts))
df=pd.DataFrame(list(dic.items()),columns=['i','Occurence'])
df.set_index(['i'], inplace=True)
df['Freq']=df['Occurence']/k
df['P({i})']=['{0:.3f}'.format(j) for j in q]
return df
interact(dice_sim,k=widgets.IntSlider(min=1000, max=50000, step=500, value=10));
interactive(children=(IntSlider(value=1000, description='k', max=50000, min=1000, step=500), Dropdown(descript…
Tester l'intéraction précédente pour plusieurs valeurs de p
Donner votre conclusion :
# Conclusion
# la simulation montra que reagit avec la meme maniere
# on remarque que la frequance est appepre egal a la valeur de la probabilite quan a deja fixer
np.random.seed(2)
m = 1
n = 10
v = np.arange(m, n+1)
print('v =', v)
np.random.shuffle(v)
print('v, shuffled =', v)
v = [ 1 2 3 4 5 6 7 8 9 10] v, shuffled = [ 5 2 6 1 8 3 4 7 10 9]
Vérifier que les permutation aléatoires sont uniforme , c'est à dire que la probabilité de générer une permutation d'élement de {1,2,3} est 1/6. En effet les permutations de {1,2,3} sont :
k =10
m = 1
n = 3
v = np.arange(m, n+1)
T=[]
for i in range(k):
np.random.shuffle(v)
w=np.copy(v)
T.append(w)
TT=[str(i) for i in T]
TT
['[1 3 2]', '[3 1 2]', '[1 2 3]', '[1 3 2]', '[3 1 2]', '[3 1 2]', '[1 3 2]', '[2 1 3]', '[3 1 2]', '[2 3 1]']
k =1000
m = 1
n = 3
v = np.arange(m, n+1)
T=[]
for i in range(k):
np.random.shuffle(v)
w=np.copy(v)
T.append(w)
TT=[str(i) for i in T]
unique, counts = np.unique(TT, return_counts=True)
dic=dict(zip(unique, counts))
df=pd.DataFrame(list(dic.items()),columns=['i','Occurence'])
df.set_index(['i'], inplace=True)
df['Freq']=df['Occurence']/k
df['P({i,j,k})']='{0:.3f}'.format(1/6)
df
Occurence | Freq | P({i,j,k}) | |
---|---|---|---|
i | |||
[1 2 3] | 169 | 0.169 | 0.167 |
[1 3 2] | 180 | 0.180 | 0.167 |
[2 1 3] | 161 | 0.161 | 0.167 |
[2 3 1] | 169 | 0.169 | 0.167 |
[3 1 2] | 157 | 0.157 | 0.167 |
[3 2 1] | 164 | 0.164 | 0.167 |
## Explication
# la simulation montra que reagit avec la meme maniere
Rappelons que l'interprétation fréquentiste de la probabilité conditionnelle basée sur un grand nombre n
de répétitions d'une expérience est $ P (A | B) ≈ n_ {AB} / n_ {B} $, où $ n_ {AB} $ est le nombre de fois où $ A \cap B $ se produit et $ n_ {B} $ est le nombre de fois où $ B $ se produit. Essayons cela par simulation et vérifions les résultats de l'exemple 2.2.5. Utilisons donc [numpy.random.choice
] (https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.random.choice.html) pour simuler les famillesn
, chacun avec deux enfants.
np.random.seed(34)
n = 10**5
child1 = np.random.choice([1,2], n, replace=True)
child2 = np.random.choice([1,2], n, replace=True)
print('child1:\n{}\n'.format(child1))
print('child2:\n{}\n'.format(child2))
child1: [2 1 1 ... 1 2 1] child2: [2 2 2 ... 2 2 1]
Ici, «child1» est un «tableau NumPy» de longueur «n», où chaque élément est un 1 ou un 2. En laissant 1 pour «fille» et 2 pour «garçon», ce «tableau» représente le sexe du enfant aîné dans chacune des familles «n». De même, «enfant2» représente le sexe du plus jeune enfant de chaque famille.
np.random.choice(["girl", "boy"], n, replace=True)
array(['boy', 'boy', 'boy', ..., 'boy', 'boy', 'boy'], dtype='<U4')
mais il est plus pratique de travailler avec des valeurs numériques.
Soit $ A $ l'événement où les deux enfants sont des filles et $ B $ l'événement où l'aîné est une fille. Suivant l'interprétation fréquentiste, nous comptons le nombre de répétitions où $ B $ s'est produit et le nommons n_b
, et nous comptons également le nombre de répétitions où $ A \cap B $ s'est produit et le nommonsn_ab
. Enfin, nous divisons n_ab
parn_b
pour approximer $ P (A | B) $.
n_b = np.sum(child1==1)
n_ab = np.sum((child1==1) & (child2==1))
print('P(both girls | elder is girl) = {:0.2F}'.format(n_ab / n_b))
P(both girls | elder is girl) = 0.50
L'esperluette &
est un élément par élément $ AND $, donc n_ab
est le nombre de familles où le premier et le deuxième enfant sont des filles. Lorsque nous avons exécuté ce code, nous avons obtenu 0,50, confirmant notre réponse $ P (\text {les deux filles | l'aîné est une fille}) = 1/2 $.
Soit maintenant $ A $ l'événement où les deux enfants sont des filles et $ B $ l'événement selon lequel au moins l'un des enfants est une fille. Alors $ A \cap B $ est le même, mais n_b
doit compter le nombre de familles où au moins un enfant est une fille. Ceci est accompli avec l'opérateur élémentaire $ OR $ |
(ce n'est pas une barre de conditionnement; c'est un $ OR $ inclusif, retournant True
si au moins un élément estTrue
).
n_b = np.sum((child1==1) | (child2==2))
n_ab = np.sum((child1==1) & (child2==1))
print('P(both girls | at least one girl) = {:0.2F}'.format(n_ab / n_b))
P(both girls | at least one girl) = 0.33
Pour nous, le résultat était de 0,33, confirmant que $ P (\text {les deux filles | au moins une fille}) = 1/3 $.